import axios from 'axios'
import { ElMessage } from 'element-plus'
import { useUserStore } from '@/stores/user'
import router from '@/router'

const service = axios.create({
  baseURL: '/api',
  timeout: 30000,
})

// 请求拦截器
service.interceptors.request.use(
  (config) => {
    const userStore = useUserStore()
    
    // 如果正在退出登录，且不是 logout 请求本身，取消请求
    const isLogoutRequest = config.url?.includes('/logout') || config.url?.endsWith('logout')
    if (userStore.isLoggingOut && !isLogoutRequest) {
      return Promise.reject(new Error('正在退出登录，请求已取消'))
    }
    
    if (userStore.token) {
      config.headers.Authorization = `Bearer ${userStore.token}`
    }
    // 确保请求头包含 Content-Type 和 Accept
    if (!config.headers['Content-Type']) {
      config.headers['Content-Type'] = 'application/json'
    }
    if (!config.headers['Accept']) {
      config.headers['Accept'] = 'application/json'
    }
    // 确保请求被识别为 JSON 请求
    config.headers['X-Requested-With'] = 'XMLHttpRequest'
    return config
  },
  (error) => {
    console.error('请求错误:', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
service.interceptors.response.use(
  (response) => {
    // 如果是文件下载（blob类型），直接返回响应
    if (response.config.responseType === 'blob' || response.data instanceof Blob) {
      return response.data
    }

    const res = response.data

    // 检查响应数据
    if (res === null || res === undefined) {
      ElMessage.error('服务器返回数据为空')
      return Promise.reject(new Error('服务器返回数据为空'))
    }

    // 确保响应数据是对象
    if (typeof res !== 'object') {
      ElMessage.error('服务器返回数据格式错误')
      return Promise.reject(new Error('服务器返回数据格式错误'))
    }

    // 检查业务状态码
    if (res.code !== undefined) {
      if (res.code === 200) {
        // 成功，返回响应数据
        return res
      } else {
        // 业务错误
        ElMessage.error(res.message || '请求失败')
        
        // 401: 未登录或token过期
        // 检查是否是 logout 请求本身，或者是否已经在退出登录过程中
        if (res.code === 401) {
          const userStore = useUserStore()
          const requestUrl = response.config.url || ''
          const isLogoutRequest = requestUrl.includes('/logout') || requestUrl.endsWith('logout')
          const skipAuthRedirect = response.config.skipAuthRedirect === true
          
          // 如果正在退出登录或者是 logout 请求本身，不重复处理
          if (!userStore.isLoggingOut && !isLogoutRequest && !skipAuthRedirect) {
            // 使用 skipApiCall 参数，避免再次调用 logout API
            userStore.logout(true)
            router.push('/login')
          }
        }
        
        return Promise.reject(new Error(res.message || '请求失败'))
      }
    }

    // 如果没有 code 字段，直接返回数据（兼容其他格式）
    return res
  },
  (error) => {
    console.error('响应错误:', error)
    console.error('错误详情:', {
      message: error.message,
      response: error.response,
      request: error.request,
      config: error.config
    })
    
    if (error.response) {
      const { status, data } = error.response

      // 处理响应数据，可能是字符串、对象或空
      let errorMessage = '请求失败'
      let errorData = null
      
      try {
        // 如果data是字符串，尝试解析
        if (typeof data === 'string') {
          if (data.trim()) {
            errorData = JSON.parse(data)
            errorMessage = errorData?.message || errorMessage
          }
        } else if (data && typeof data === 'object') {
          errorData = data
          errorMessage = data?.message || errorMessage
        }
      } catch (e) {
        // 解析失败，使用默认消息
        console.warn('解析错误响应失败:', e)
      }

      if (status === 401) {
        const userStore = useUserStore()
        const requestUrl = error.config?.url || ''
        const isLogoutRequest = requestUrl.includes('/logout') || requestUrl.endsWith('logout')
        const skipAuthRedirect = error.config?.skipAuthRedirect === true
        
        // 如果正在退出登录或者是 logout 请求本身，不重复处理
        if (!userStore.isLoggingOut && !isLogoutRequest && !skipAuthRedirect) {
          // 使用 skipApiCall 参数，避免再次调用 logout API
          userStore.logout(true)
          router.push('/login')
          ElMessage.error(errorMessage || '登录已过期，请重新登录')
        }
      } else if (status === 403) {
        ElMessage.error(errorMessage || '无权限访问')
      } else if (status === 500) {
        // 500错误，尝试从错误数据中获取详细信息
        const message = errorData?.message || errorMessage || '服务器错误，请稍后重试'
        ElMessage.error(message)
        // 开发环境下，在控制台输出详细错误信息
        if (process.env.NODE_ENV === 'development') {
          console.error('服务器错误详情:', {
            status,
            data: errorData,
            originalData: data,
            error: error
          })
        }
      } else if (status === 422) {
        // 验证错误：不在拦截器中显示全局消息，将错误信息附加到 error 对象，由组件处理
        // 这样可以让组件将错误信息设置到表单字段上，避免重复显示错误
        // 确保 error.response 存在
        if (!error.response) {
          error.response = {}
        }
        error.response.status = status
        error.response.data = errorData || data || {}
        // 将 errors 信息附加到 error 对象的多个位置，方便组件获取
        error.errors = errorData?.errors || data?.errors
        error.message = errorData?.message || data?.message || '数据验证失败'
        // 不显示 ElMessage，直接 reject，让组件处理
        return Promise.reject(error)
      } else {
        ElMessage.error(errorMessage || `请求失败 (${status})`)
      }
    } else if (error.request) {
      // 请求已发出但没有收到响应
      ElMessage.error('网络错误，请检查网络连接或服务器状态')
    } else {
      // 请求配置出错
      ElMessage.error(error.message || '请求配置错误')
    }

    return Promise.reject(error)
  }
)

export default service

